class Solution {
public:
    bool isAnagram(string s, string t) 
    {
        int values[26] = {0};

        // 记录t中字符出现的次数
        for(int i = 0; i < t.size(); i++)
        {
            values[t[i] - 'a']++;
        }

        // 遍历s，将哈希表中的元素对应相减
        for(int i = 0; i < s.size(); i++)
        {
            values[s[i] - 'a']--;
        }

        // 查看哈希表中是否存在元素
        bool res = true;
        for(int i = 0; i < 26; i++)
        {
            if(values[i] != 0)
            {
                res = false;
            }
        }

        return res;
    }
};

class Solution {
public:
    bool wordPattern(string pattern, string s) 
    {
        vector<string> words;

        stringstream ss(s);
        string str;

        while(getline(ss, str, ' '))
        {
            words.push_back(str);
        }

        // 注意这一条判断语句，别忘记了
        if(pattern.size() != words.size())
        {
            return false;
        }

        // 建立字符到字符串的映射
        unordered_map<char, string> patternToStr;

        // 记录已经有字符对应的字符串
        unordered_set<string> hasWord;

        for(int i = 0; i < pattern.size(); i++)
        {
            char c = pattern[i]; 
            string word = words[i];

            // 该字符还没有建立对应的单词映射
            if(!patternToStr.count(c))
            {
                // 但是与之对应的单词却有自己的字符了
                if(hasWord.count(word))
                {
                    return false;
                }   

                // 建立该字符到单词的映射
                patternToStr[c] = word;
            }
            else // 该字符已经有对应的单词了
            {   
                // 如若该字符所对应的单词与实际不符
                if(patternToStr[c] != word)
                {
                    return false;
                }
            }

            hasWord.insert(word);
        }

        return true;
    }
};


